home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / general / viewers / polyview / polyvw31.lha / Polyview3.1 / new / pvaction.c < prev    next >
C/C++ Source or Header  |  1993-06-23  |  7KB  |  220 lines
  1. /*****************************************************************************
  2.  * NCSA Polyview 3.0                                                         *
  3.  *                                                                           *
  4.  * Version 3 changes and additions by Marc Andreessen.                       *
  5.  * Version 2 by Brian Calvert.                                               *
  6.  *                                                                           *
  7.  * Software Development Group                                                *
  8.  * National Center for Supercomputing Applications                           *
  9.  * University of Illinois at Urbana-Champaign                                *
  10.  *                                                                           *
  11.  * This is BETA release software.  As such it may contain software bugs and  *
  12.  * exhibit inconsistencies.                                                  *
  13.  *                                                                           *
  14.  * Please send bug reports to polyview@ncsa.uiuc.edu.                        *
  15.  *                                                                           *
  16.  * Copyright (c) 1992 The Board of Trustees of the University of Illinois.   *
  17.  *                                                                           *
  18.  * Permission to use, copy, and modify this software and its                 *
  19.  * documentation for educational, research, and non-profit purposes is       *
  20.  * hereby granted, provided that the above copyright notice, the original    *
  21.  * authors names, and this permission notice appear in all such copies.      *
  22.  * Any distribution of this software requires the explicit and written       *
  23.  * authorization of the authors.                                             *
  24.  *                                                                           *
  25.  * The University of Illinois makes no representations about the             *
  26.  * suitability of this software for any purpose.  It is provided "as is"     *
  27.  * without warranty of any kind.                                             *
  28.  *****************************************************************************/
  29.  
  30. /* $Header: /usr3/people/gbourhis/pv3/new/RCS/pvaction.c,v 1.1 92/09/18 10:55:26 marca Exp $ */
  31.  
  32. #ifdef RCSLOG
  33. $Log:    pvaction.c,v $
  34.  * Revision 1.1  92/09/18  10:55:26  marca
  35.  * Initial revision
  36.  * 
  37. #endif
  38.  
  39. #include "pv.h"
  40.  
  41. action_t *new_action (state_t *state, int (*action_fn)(), int argc, 
  42.                       arg_t arg[MAXACTIONARGS], int steps)
  43. {
  44.   action_t *new;
  45.     
  46.   if (state->action_free == NULL) 
  47.     {
  48.       /* If no action exists in the free list, make one. */
  49.       new = (action_t *) PVMALLOC(sizeof(action_t));
  50.     }
  51.   else 
  52.     {
  53.       /* Get an action from the action_free list, if one exists. */
  54.       new = state->action_free;
  55.       state->action_free = new->next_serial;
  56.     }
  57.   
  58.   /* Internal check. */
  59.   assert (new != NULL);
  60.  
  61.   /* Make sure there is a valid pointer before loading the record. */
  62.   /* Fill the action fields with values specified. */
  63.   new->action_fn = action_fn;
  64.   new->argc = argc;
  65.   new->count = steps;
  66.   new->countdown = steps;
  67.   while (--argc >= 0)
  68.     new->arg[argc] = arg[argc];
  69.   
  70.   return new;
  71. }
  72.  
  73.  
  74. action_t *add_action (state_t *state, int (*action_fn)(), int argc, 
  75.                       arg_t arg[MAXACTIONARGS], 
  76.                       int steps, int global, int at_current)
  77. {
  78.   action_t *new;
  79.   action_t *insert;
  80.   
  81.   new = new_action(state, action_fn, argc, arg, steps);
  82.   
  83.   if (new != NULL) {
  84.     /* Make sure there is a valid pointer before loading the record. */
  85.     /* Fill the action fields with values specified. */
  86.     new->action_fn = action_fn;
  87.     new->argc = argc;
  88.     new->count = steps;
  89.     new->countdown = steps;
  90.     new->global = global;
  91.     while (--argc >= 0)
  92.       new->arg[argc] = arg[argc];
  93.     
  94.     if (at_current == TRUE) 
  95.       {
  96.         /* If adding at the current point, then get a pointer to */
  97.         /* the head of the list. */
  98.         insert = state->action_head;
  99.       }
  100.     else 
  101.       {
  102.         /* If adding at the end of the list, then get a pointer to */
  103.         /* the tail. */
  104.         insert = state->action_tail;
  105.       }
  106.     
  107.     if (insert == NULL) 
  108.       {
  109.         /* This is the only action in the list.  As a result, */
  110.         /* it is both the head and the tail. */
  111.         state->action_head = state->action_tail = new;
  112.         
  113.         /* This action has no relatives. */
  114.         new->next_serial = NULL;
  115.       }
  116.     else 
  117.       {
  118.         /* Add the new action serially after the insert */
  119.         /* point. */
  120.         new->next_serial = insert->next_serial;
  121.         
  122.         insert->next_serial = new;
  123.         
  124.         /* If the new action was inserted (serially) */
  125.         /* after the tail of the list, update the */
  126.         /* tail pointer. */
  127.         if (insert == state->action_tail)
  128.           state->action_tail = new;
  129.       }
  130.   }
  131.   
  132.   /* Return value is the pointer to the new record. */
  133.   return new;
  134. }
  135.  
  136.  
  137.  
  138. action_t *next_ser_action (state_t *state, action_t *current)
  139. {
  140.   if (current == NULL) 
  141.     {
  142.       /* If there are no current actions, there is not a next serial */
  143.       /* action. */
  144.       return NULL;
  145.     }
  146.   
  147.   if (current->countdown <= 0) 
  148.     {
  149.       /* If the countdown is zero, remove the action from the list. */
  150.       /* Adjust the head of the list. */
  151.       state->action_head = current->next_serial;
  152.       
  153.       /* Free up the old action record for reuse. */
  154.       free_action(state, current);
  155.       
  156.       /* Get the new current pointer. */
  157.       current = state->action_head;
  158.     }
  159.     
  160.   if (current == NULL) 
  161.     {
  162.       /* If there is no next serial action, there are no members in */
  163.       /* the list any more. */
  164.       state->action_head =
  165.         state->action_tail = NULL;
  166.     }
  167.   else 
  168.     {
  169.       /* If there is still a "current" action, its count should be */
  170.       /* marked down. */
  171.       (current->countdown)--;
  172.     }
  173.   
  174.   return current;
  175. }
  176.  
  177.  
  178. int free_action (state_t *state, action_t *action)
  179. {
  180. #if 0
  181.   /* This isn't done since 'move camera' actions get freed twice
  182.      in some cases; dunno why; code is screwed up; not my fault. */
  183.  
  184.   /* Free the fields of the args. */
  185.   while (--(action->argc) >= 0) {
  186.     PVFREE(action->arg[action->argc].description);
  187.     PVFREE(action->arg[action->argc].value);
  188.   }
  189. #endif
  190.   
  191.   /* Add the action structure to the system's free list of old actions. */
  192.   action->next_serial = state->action_free;
  193.   state->action_free = action;
  194.   
  195.   return ST_OKAY;
  196. }
  197.  
  198.  
  199. int do_action (state_t *state, action_t *action)
  200. {
  201.   window_t *win;
  202.   int i;
  203.  
  204.   assert (action != NULL);
  205.   assert (action->action_fn != NULL);
  206.  
  207.   if (action->global) 
  208.     {
  209.       return((*(action->action_fn))(state, action, NULL));
  210.     }
  211.   else 
  212.     {
  213.       FOR_EACH_ACTIVE(win, state) 
  214.         {
  215.           (*(action->action_fn))(state, action, win);
  216.         }
  217.       return ST_OKAY;
  218.     }
  219. }
  220.